package cn.iluwen.airline.Services;

import cn.iluwen.airline.Entities.User;
import cn.iluwen.airline.Entities.UserRegistration;
import cn.iluwen.airline.Mapper.UserMapper;
import cn.iluwen.airline.utils.BCrypt;
import cn.iluwen.airline.utils.PageUtils;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.UUID;

/**
 * 用户服务类。
 * 处理用户账号的查询、更新、删除以及登录验证等业务逻辑。
 * 注册相关功能已移至UserRegistrationService。
 */
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    
    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    
    /**
     * 用户登录
     * @param username 用户名
     * @param password 密码
     * @return 登录成功的用户对象
     */
    public User login(String username, String password) {
        // 查询用户
        User user = userMapper.findByUsername(username);
        if (user == null) {
            throw new RuntimeException("用户名或密码错误");
        }
        
        // 验证密码
        if (!BCrypt.matches(password, user.getPassword())) {
            throw new RuntimeException("用户名或密码错误");
        }
        
        return user;
    }
    
    /**
     * 根据ID查询用户
     * @param userId 用户ID
     * @return 用户对象
     */
    public User getUserById(String userId) {
        return userMapper.findById(userId);
    }
    
    /**
     * 根据用户名查询用户
     * @param username 用户名
     * @return 用户对象
     */
    public User getUserByUsername(String username) {
        return userMapper.findByUsername(username);
    }
    
    /**
     * 根据邮箱查询用户
     * @param email 邮箱
     * @return 用户对象
     */
    public User getUserByEmail(String email) {
        return userMapper.findByEmail(email);
    }
    
    /**
     * 获取所有用户
     * @return 用户列表
     */
    public List<User> getAllUsers() {
        return userMapper.findAllUsers();
    }
    
    /**
     * 分页获取所有用户
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 分页后的用户列表
     */
    public PageInfo<User> getUsersWithPaging(int pageNum, int pageSize) {
        PageUtils.startPage(pageNum, pageSize);
        List<User> users = userMapper.findUsersWithPaging();
        return PageUtils.getPageInfo(users);
    }
    
    /**
     * 根据创建日期范围分页查询用户
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 分页后的用户列表
     */
    public PageInfo<User> getUsersByDateRange(LocalDateTime startDate, LocalDateTime endDate, int pageNum, int pageSize) {
        PageUtils.startPage(pageNum, pageSize);
        String startDateStr = startDate.format(DATE_FORMATTER);
        String endDateStr = endDate.format(DATE_FORMATTER);
        List<User> users = userMapper.findUsersByDateRange(startDateStr, endDateStr);
        return PageUtils.getPageInfo(users);
    }
    
    /**
     * 根据用户名关键词分页查询用户
     * @param username 用户名关键词
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 分页后的用户列表
     */
    public PageInfo<User> getUsersByUsernameLike(String username, int pageNum, int pageSize) {
        PageUtils.startPage(pageNum, pageSize);
        List<User> users = userMapper.findUsersByUsernameLike(username);
        return PageUtils.getPageInfo(users);
    }
    
    /**
     * 根据邮箱关键词分页查询用户
     * @param email 邮箱关键词
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 分页后的用户列表
     */
    public PageInfo<User> getUsersByEmailLike(String email, int pageNum, int pageSize) {
        PageUtils.startPage(pageNum, pageSize);
        List<User> users = userMapper.findUsersByEmailLike(email);
        return PageUtils.getPageInfo(users);
    }
    
    /**
     * 更新用户信息
     * @param user 用户对象（含userId）
     * @return 更新后的用户对象
     */
    @Transactional
    public User updateUser(User user) {
        // 检查用户是否存在
        User existingUser = userMapper.findById(user.getUserId());
        if (existingUser == null) {
            throw new RuntimeException("用户不存在");
        }
        
        // 若修改了用户名，检查新用户名是否与其他用户冲突
        if (!existingUser.getUsername().equals(user.getUsername()) && 
            userMapper.findByUsername(user.getUsername()) != null) {
            throw new RuntimeException("用户名已被注册");
        }
        
        // 若修改了邮箱，检查新邮箱是否与其他用户冲突
        if (!existingUser.getEmail().equals(user.getEmail()) &&
            userMapper.findByEmail(user.getEmail()) != null) {
            throw new RuntimeException("邮箱已被注册");
        }
        
        // 设置更新时间
        user.setUpdatedAt(LocalDateTime.now());
        
        // 若未修改密码，保留原密码
        if (user.getPassword() == null || user.getPassword().isEmpty()) {
            user.setPassword(existingUser.getPassword());
        } else {
            // 若修改了密码，加密新密码
            user.setPassword(BCrypt.encrypt(user.getPassword()));
        }
        
        // 更新用户
        userMapper.updateUser(user);
        
        return user;
    }
    
    /**
     * 修改密码
     * @param userId 用户ID
     * @param oldPassword 原密码
     * @param newPassword 新密码
     * @return 是否成功
     */
    @Transactional
    public boolean changePassword(String userId, String oldPassword, String newPassword) {
        // 查询用户
        User user = userMapper.findById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        
        // 验证原密码
        if (!BCrypt.matches(oldPassword, user.getPassword())) {
            throw new RuntimeException("原密码错误");
        }
        
        // 加密新密码并更新
        String encodedNewPassword = BCrypt.encrypt(newPassword);
        userMapper.updatePassword(userId, encodedNewPassword);
        
        return true;
    }
    
    /**
     * 删除用户
     * @param userId 用户ID
     * @return 是否成功
     */
    @Transactional
    public boolean deleteUser(String userId) {
        // 查询用户
        User user = userMapper.findById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        
        // 删除用户
        userMapper.deleteUser(userId);
        
        return true;
    }
    
    /**
     * 通过注册记录创建用户
     * @param registration 注册记录
     * @return 创建的用户对象
     */
    @Transactional
    public User createUserFromRegistration(UserRegistration registration) {
        // 检查用户名/邮箱是否已存在
        if (userMapper.findByEmail(registration.getEmail()) != null) {
            throw new RuntimeException("邮箱已被注册");
        }
        
        if (userMapper.findByUsername(registration.getUsername()) != null) {
            throw new RuntimeException("用户名已被注册");
        }
        
        // 创建用户对象
        User user = new User();
        user.setUserId(UUID.randomUUID().toString());
        user.setUsername(registration.getUsername()); // 使用注册时设置的用户名
        user.setPassword(registration.getPassword()); // 密码已经加密
        user.setEmail(registration.getEmail());
        user.setPhone(registration.getPhone());
        user.setRealName(registration.getRealName());
        user.setIdCard(registration.getIdCard());
        
        LocalDateTime now = LocalDateTime.now();
        user.setCreatedAt(now);
        user.setUpdatedAt(now);
        
        // 保存用户
        userMapper.createUser(user);
        
        return user;
    }

    /**
     * 验证密码
     * @param user 注册记录
     * @param plainPassword 明文密码
     * @return 验证结果
     */
    public boolean verifyPassword(User user, String plainPassword) {
        return BCrypt.matches(plainPassword, user.getPassword());
    }

}
